package clases;
/**
	 * @Segmentacion.java
	 *
	 *
	 * @proyecto : Vision Artificial
	 * @version 1.00 2008/4/23
	 */
	import java.awt.Color;
import java.awt.image.BufferedImage;
	
	
public class Segmentacion {
	
		private Integer Ancho;
		private Integer Largo;
		private Integer Test;
		private Integer Mitad = new Integer(0);
		private Integer Pivote = new Integer(0);
		private BufferedImage ImagenOriginal;
		private Integer color[];
	
		public Segmentacion(int Largo , int Ancho ) {
			this.Ancho = Ancho;
			this.Largo = Largo;
			color = new Integer [6];
			// Rojo ...
			color[0] = new Color (255,0,0).getRGB();
			// Verde ...
			color[1] = new Color (0,255,0).getRGB();
			// Azul ...
			color[2] = new Color (0,0,255).getRGB();
			// Amarillo ...
			color[3] = new Color (255,255,0).getRGB();
			// Blanco ...
			color[4] = new Color (255,255,255).getRGB();
			// Negro ...
			color[5] = new Color (0,0,0).getRGB();
		}
		
		public  BufferedImage Binarizacion (BufferedImage ImageBfrd , Integer n ) {
			Integer Contador = new Integer(0) ;
			Long Umbral = new Long(500000);
			BufferedImage Nueva_Imagen = new BufferedImage(320,240,BufferedImage.TYPE_INT_RGB) ;
			ImagenOriginal = ImageBfrd;
			for (int i = 0; i <Largo ; i ++) {
				for ( int j = 0; j <Ancho ; j ++ ) {
					if ( ImageBfrd.getRGB(i,j) <-Umbral * n) {
						Contador ++;
						Nueva_Imagen.setRGB(i,j,color[5]);
					} else {
						Nueva_Imagen.setRGB(i,j,color[4]);
					} // fin del if
				} // fin del for j
			}
			return Nueva_Imagen;
		}
		
	public BufferedImage Bordes (BufferedImage ImageBfrd ) {
		//BufferedImage Nueva_Imagen = new BufferedImage(Largo,Ancho,BufferedImage.TYPE_INT_RGB);
		BufferedImage Nueva_Imagen = ImagenOriginal;
		for (Integer i = new Integer(1); i <Largo - 1 ; i ++) {
			for ( Integer j = new Integer(1); j <Ancho - 1 ; j ++ ) {
		
				if (ImageBfrd.getRGB(i,j) == -1 && ImageBfrd.getRGB(i-1,j) != -1 && ImageBfrd.getRGB(i+1,j) == -1) {
					Nueva_Imagen.setRGB(i,j,color[0]);
				}
				else if (ImageBfrd.getRGB(i,j) == -1 && ImageBfrd.getRGB(i+1,j) != -1 && ImageBfrd.getRGB(i-1,j) == -1) {
					Nueva_Imagen.setRGB(i,j,color[0]);
				} else if (ImageBfrd.getRGB(i,j) == -1 && ImageBfrd.getRGB(i,j-1) != -1 && ImageBfrd.getRGB(i,j+1) == -1) {
					Nueva_Imagen.setRGB(i,j,color[0]);
				} else if (ImageBfrd.getRGB(i,j) == -1 && ImageBfrd.getRGB(i,j+1) != -1 && ImageBfrd.getRGB(i,j-1) == -1) {
					Nueva_Imagen.setRGB(i,j,color[0]);
				} // fin del if
			} // fin del for
		} // fin del for
		return Nueva_Imagen;
	} // fin de la metodo
	// Trabajo de vectores ..................
	
	public Integer[] ObtenerVector (BufferedImage ImagenRGB ) {
		Integer [] VectorRGB  = new Integer[Largo*Ancho];
		Integer Contador = new Integer(0) ;
		// tomar valores
		for (int i = 0; i <Largo ; i ++) {
			for ( int j = 0; j <Ancho ; j ++ ) {
			  VectorRGB[Contador] = ImagenRGB.getRGB(i,j);
			  Contador ++ ;
			}
		}
		return VectorRGB;
	}  // fin del metodo
	
	public Integer [] QuickSort(Integer[] Arreglo,  int Izq, int Der) {
		// Varaiables para recorrido del Arreglo (Izq y Der)
		Mitad = 0;
		Integer i = new Integer(Izq);
		Integer j = new Integer(Der);
		// Declaramos el Pivote
		Mitad = Math.round(( Izq + Der )/2);
		Pivote = Arreglo[Mitad];
		while (i<=j) {
			//Recorremos primero de Izq a Der,, hasta que un elemento de la Izquierda sea Mayor al Pivote.
			while (Arreglo[i]<Pivote) {
				i++;
			}
			while (Arreglo[j]>Pivote) {
				//Despues a la Der a Izq ,,  hasta que un elemento de la Derecha sea Menor al Pivote.
				j--;
			}
		// Si un elemento de la Izq es Menor o Igual a un ELemento de la Der ,, estos se Intercambian...
			if (i<=j) {
				// Intercambio de Valores
				Integer Temp = Arreglo[i];
				Arreglo[i] = Arreglo[j];
				Arreglo[j] = Temp;
				//Recooremos
				i++;
				j--;
			} // Fin del if
		} // Fin del while
		if ( Izq <j ) {
			QuickSort(Arreglo, Izq, j);
		}
		if (i <Der ) {
			QuickSort(Arreglo, i, Der);
		}
		return Arreglo;
	} // fin del metodo QuickSort
	
	
	public BufferedImage  VectorToImagen(int[] VectorRGB) {
		Integer Contador = new Integer(0) ;
		// Creamos un nuevo BufferedImage ...
			BufferedImage Nueva_Imagen = new BufferedImage(320,240,BufferedImage.TYPE_INT_RGB) ;
			for (int i = 0; i <Largo ; i ++) {
				for ( int j = 0; j <Ancho ; j ++ ) {
					Nueva_Imagen.setRGB(i,j,VectorRGB[Contador]);
					Contador ++ ;
				}
			}	
		return Nueva_Imagen;
	}  // fin del metodo
	
	
	// Deteccion de trayectorias
	public BufferedImage Pintar_Region  (BufferedImage ImageBfrd , int c ) {
		for (int i = 0; i <240 ; i ++) {
		ImageBfrd.setRGB(10,i,color[c]);
		ImageBfrd.setRGB(310,i,color[c]);
		}
		return ImageBfrd;
	}
	
	
	public BufferedImage  Detectar_Region  (BufferedImage ImageBfrd ) {
		Integer n = new Integer(0);
		ImageBfrd = Pintar_Region(ImageBfrd,1);
		for (int i = 310; i <320 ; i ++) {
			for (int j = 0; j <240 ; j ++) {
				if (ImageBfrd.getRGB(i,j) == color[5]) {
					ImageBfrd = Pintar_Region(ImageBfrd,0);
					break;
				} // fin del if
			}  // fin del for j
		} // fin del for i
		return ImageBfrd;
	} // fin del metodo
	
	
	// resta de imagenes
	public BufferedImage  Detectar_Region  (BufferedImage Image1 , BufferedImage Image2  ) {
		 for (int i = 0; i <Largo ; i ++) {
			for ( int j = 0; j <Ancho ; j ++ ) {
				if ( Math.abs(Image1.getRGB(i,j) - Image2.getRGB(i,j) ) > 5000000 )  {
					Image2.setRGB(i,j,color[5]);
				} else {
					Image2.setRGB(i,j,color[4]);
				} // fin del if
			} // fin del for j
		} // fin del for i
		return Image2;
	} // fin del metodo
	
	
	// Visualizacion de formas ...
	public BufferedImage  Dibujar  (BufferedImage ImagenBfrd , int x , int y , int w , int h ) {
	// Dibujar Cuadrado ...
		for (int i = x; i <w ; i ++) {
			for (int j = y; j <h ; j ++) {
			   ImagenBfrd.setRGB(x,j,color[0]);
			   ImagenBfrd.setRGB(w,j,color[0]);
			   ImagenBfrd.setRGB(i,y,color[0]);
			   ImagenBfrd.setRGB(i,h,color[0]);
			} // fin del for j
		} // fin del for y
		return ImagenBfrd;
	} // fin del metodo
	
	
	// Encontrar puntos clave ...
	public  BufferedImage Puntos  (BufferedImage ImagenP , BufferedImage ImagenA  ) {
		// Variables ...
		int x , x2 , y , y2 , w , w2, h , h2, aux ;
		// Iniciamos valores con ...
		w = x = Largo-1;
		h = y = Ancho-1;
		// Leer mapa de bits ...
		for (int i = 0; i <Largo ; i ++) {
			for ( int j = 0; j <Ancho ; j ++ ) {
				if (ImagenP.getRGB(i,j) == color[5]) { // si encontramos punto de referencia
					// Guardar en Valores ...
					x2 = i;
					y2 = j;
					w2 = Largo - i;
					h2 = Ancho - j;
					// Evaluar puntos ...
					if (x> x2) { // realizar intercambio
						aux = x2;
						x2 = x;
						x = aux;
					}
					if (y> y2) { // realizar intercambio
						aux = y2;
						y2 = x;
						y = aux;
					}
	// --------------------------------------------------------
					if (w> w2) { // realizar intercambio
						aux = w2;
						w2 = w;
						w = aux;
					}
					if (h> h2) { // realizar intercambio
						aux = h2;
						h2 = h;
						h = aux;
					}
				} // fin del if
			} // fin del for j
		} // fin del for i
	   // Acomodamos Valores ...
		w = Largo - w;
		h = Ancho - h;
		if (h <1) {
			Test++;
			System.out.println("No hay dimension" + Test);
		}
		return Dibujar(ImagenA,x,y,w,h);
	} // fin del metodo
}  // fin de la clase



